package com.king.juc.n8.threadpooldemo.threadpool;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.SynchronousQueue;

import static com.king.juc.utils.ThreadUtil.sleep;

/**
 * ThreadPoolExecutor 工厂
 *
 * @author king
 * @date 2020/12/9 22:57
 */
@Slf4j(topic = "c.ExecutorsDemo")
public class ExecutorsDemo {
    public static void main(String[] args) {

        /**
         * 特点
         *      核心线程数 -- 最大线程数(没有救急线程被创建), 因此也无需超时时间
         *      阻塞队列是无界的, 可以放任意数量的任务
         *
         * 队列采用了 LinkedBlockingQueue 适用于任务量已知, 相对耗时的任务
         */
//        Executors.newFixedThreadPool(1, new ThreadFactory() {
//            private AtomicInteger pool = new AtomicInteger(1);
//            @Override
//            public Thread newThread(Runnable r) {
//                return new Thread(r, "pool-" + pool.getAndIncrement());
//            }
//        });

        /**
         * 特点
         *      核心线程数是 0, 最大线程数是 Integer.MAX_VALUE, 救急线程的空闲生存时间是 60s,意味着
         *          全部都是救急线程(60s 后可以回收)
         *          救急现场可以无限创建
         *
         * 队列采用了 SynchronousQueue 实现特点是, 它没有容量, 没有线程来取是放不进去的
         * 整个线程池表现为线程数会根据任务量不断增长, 没有上限, 当任务执行完毕, 空闲 1分钟后释放线程.
         * 适合任务数比较密集, 但每个任务执行时间较短的情况
         */
//        Executors.newCachedThreadPool();
//        synchronousQueueDemo();

        /**
         * 使用场景
         *      希望多个任务排队执行. 线程数固定为 1, 任务数多于 1 时, 会放入无界队列排队. 任务执行完毕, 这唯一的现场也不会被释放.
         *
         * 区别
         *      自己创建一个单线程串行执行任务, 如果任务执行失败而终止那么没有任何补救措施, 而线程池还会新建一个线程, 保证池的正常工作.
         *      newSingleThreadExecutor() 线程池个数始终为 1, 不能修改.
         *          FinalizableDelegatedExecutorService 应用的是装饰器模式, 只对外暴露了 ExecutorService 接口, 因此不能调用 ThreadPoolExecutor 中特有的方法.
         *
         *      newFixedThreadPool() 初始时为 1, 以后还可以修改
         *          对外暴露的是 ThreadPoolExecutor 对象, 可以强转后调用 setCorePoolSize 等方法进行修改
         */
        newSingleThreadExecutorDemo();

    }

    private static void newSingleThreadExecutorDemo() {
        ExecutorService pool = Executors.newSingleThreadExecutor();
        pool.execute(() -> {
            log.debug("1");
            int i = 1 / 0;
        });

        pool.execute(() -> log.debug("2"));
        pool.execute(() -> log.debug("3"));
    }

    private static void synchronousQueueDemo() {
        SynchronousQueue<Integer> queue = new SynchronousQueue<>();
        new Thread(() -> {
            try {
                log.debug("putting {}", 1);
                queue.put(1);
                log.debug("{} putted", 1);

                log.debug("putting {}", 2);
                queue.put(2);
                log.debug("{} putted", 2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t1").start();

        sleep(1);

        new Thread(() -> {
            try {
                log.debug("take {}", 1);
                queue.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t2").start();

        sleep(1);

        new Thread(() -> {
            try {
                log.debug("take {}", 2);
                queue.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t3").start();
    }
}
